#ifndef LOGGER_H
#define LOGGER_H

#include <string>
#include <iostream>
#include <fstream>
#include <mutex>
#include <chrono>
#include <iomanip>
#include <sstream>

/**
 * @brief 日志级别枚举
 */
enum class LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR
};

/**
 * @brief 简单日志系统
 * 用于记录任务调度器的运行日志
 */
class Logger {
public:
    /**
     * @brief 获取单例实例
     * @return Logger实例引用
     */
    static Logger& getInstance() {
        static Logger instance;
        return instance;
    }
    
    /**
     * @brief 设置日志级别
     * @param level 日志级别
     */
    void setLogLevel(LogLevel level) {
        std::lock_guard<std::mutex> lock(mutex_);
        logLevel_ = level;
    }
    
    /**
     * @brief 设置日志文件路径
     * @param filepath 日志文件路径
     */
    void setLogFile(const std::string& filepath) {
        std::lock_guard<std::mutex> lock(mutex_);
        logfile_.open(filepath, std::ios::out | std::ios::app);
    }
    
    /**
     * @brief 记录调试日志
     * @param message 日志消息
     */
    void debug(const std::string& message) {
        log(LogLevel::DEBUG, message);
    }
    
    /**
     * @brief 记录信息日志
     * @param message 日志消息
     */
    void info(const std::string& message) {
        log(LogLevel::INFO, message);
    }
    
    /**
     * @brief 记录警告日志
     * @param message 日志消息
     */
    void warning(const std::string& message) {
        log(LogLevel::WARNING, message);
    }
    
    /**
     * @brief 记录错误日志
     * @param message 日志消息
     */
    void error(const std::string& message) {
        log(LogLevel::ERROR, message);
    }

private:
    Logger() : logLevel_(LogLevel::INFO) {}
    
    ~Logger() {
        if (logfile_.is_open()) {
            logfile_.close();
        }
    }
    
    /**
     * @brief 记录日志
     * @param level 日志级别
     * @param message 日志消息
     */
    void log(LogLevel level, const std::string& message) {
        if (level < logLevel_) {
            return;
        }
        
        std::lock_guard<std::mutex> lock(mutex_);
        
        // 获取当前时间
        auto now = std::chrono::system_clock::now();
        auto time_t = std::chrono::system_clock::to_time_t(now);
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            now.time_since_epoch()) % 1000;
        
        std::ostringstream oss;
        oss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
        oss << '.' << std::setfill('0') << std::setw(3) << ms.count();
        
        // 日志级别字符串
        std::string levelStr;
        switch (level) {
            case LogLevel::DEBUG:   levelStr = "DEBUG"; break;
            case LogLevel::INFO:    levelStr = "INFO";  break;
            case LogLevel::WARNING: levelStr = "WARN";  break;
            case LogLevel::ERROR:   levelStr = "ERROR"; break;
        }
        
        // 构造日志行
        std::string logLine = "[" + oss.str() + "] [" + levelStr + "] " + message + "\n";
        
        // 输出到控制台
        std::cout << logLine;
        
        // 输出到日志文件
        if (logfile_.is_open()) {
            logfile_ << logLine;
            logfile_.flush();
        }
    }
    
    LogLevel logLevel_;
    std::ofstream logfile_;
    std::mutex mutex_;
};

#endif // LOGGER_H